const app = getApp()

Page({
  data: {
    messages: [],
    inputValue: '',
    isLoading: false,
    currentModelName: '',
    hasDeepThinking: false,
    elderlyModeEnabled: false,
    deepThinkingEnabled: false,
    quotedContent: '',
    quotedSource: '',
    scrollIntoView: '',
    loadingStartTime: null,
    keyboardHeight: 0
  },

  onLoad() {
    this.updateData()
    
    // 添加错误处理，确保loading不会一直显示
    this.catchAPIErrors()
    
    // 监听键盘高度变化
    wx.onKeyboardHeightChange(res => {
      this.setData({
        keyboardHeight: res.height
      })
      
      // 键盘弹出时自动滚动到底部
      if (res.height > 0) {
        setTimeout(() => {
          this.scrollToBottom()
        }, 300) // 给UI渲染更多时间
      } else {
        // 键盘收起时，也滚动到底部
        setTimeout(() => {
          this.scrollToBottom()
        }, 100)
      }
    })
    
    // 初始化时确保键盘高度为0
    this.setData({
      keyboardHeight: 0
    })
  },
  
  onShow() {
    this.updateData()
  },
  
  onHide() {
    // 页面隐藏时，确保隐藏loading
    if (this.data.isLoading) {
      wx.hideLoading()
    }
  },
  
  onUnload() {
    // 页面卸载时，确保隐藏loading
    if (this.data.isLoading) {
      wx.hideLoading()
    }
    
    // 清除定时器
    if (this.timeoutCheck) {
      clearInterval(this.timeoutCheck)
    }
    
    // 取消键盘监听
    wx.offKeyboardHeightChange()
  },
  
  // 为API请求添加全局错误处理
  catchAPIErrors() {
    // 设置请求超时处理
    const timeoutCheck = setInterval(() => {
      if (this.data.isLoading) {
        const loadingTime = Date.now() - this.data.loadingStartTime
        // 如果加载超过30秒，自动取消loading
        if (loadingTime > 30000) {
          clearInterval(timeoutCheck)
          wx.hideLoading()
          this.setData({ isLoading: false })
          app.globalData.isLoading = false
          
          wx.showToast({
            title: '请求超时，请稍后重试',
            icon: 'none',
            duration: 2000
          })
        }
      }
    }, 5000) // 每5秒检查一次
    
    // 页面卸载时清除定时器
    this.timeoutCheck = timeoutCheck
  },
  
  // 更新页面数据
  updateData() {
    const globalData = app.globalData
    
    // 获取当前会话的消息
    const messages = globalData.currentSession ? globalData.currentSession.messages : []
    
    // 获取当前模型信息
    const currentModel = globalData.currentSession ? 
      globalData.availableModels.find(m => m.id === globalData.currentSession.model) : null
    
    this.setData({
      messages: messages,
      isLoading: globalData.isLoading,
      currentModelName: currentModel ? currentModel.name : '未选择',
      hasDeepThinking: currentModel ? currentModel.hasDeepThinking : false,
      elderlyModeEnabled: globalData.elderlyModeEnabled,
      deepThinkingEnabled: globalData.deepThinkingEnabled
    }, () => {
      // 数据更新完成后滚动到底部
      if (messages.length > 0) {
        this.scrollToBottom();
      }
    })
  },
  
  // 滚动到底部
  scrollToBottom() {
    const messagesLength = this.data.messages.length;
    if (messagesLength > 0) {
      const lastMessageId = `message-${messagesLength - 1}`;
      this.setData({
        scrollIntoView: lastMessageId
      });
    }
  },
  
  // 输入框内容变化
  onInputChange(e) {
    console.log('输入内容变化:', e.detail.value, this.data.isLoading)
    
    // 直接设置输入值，不做任何处理
    this.setData({
      inputValue: e.detail.value
    })
  },
  
  // 发送消息
  sendMessage() {
    console.log('尝试发送消息, 当前输入:', this.data.inputValue)
    const content = this.data.inputValue.trim()
    if (!content || this.data.isLoading) {
      console.log('无法发送: 内容为空或正在加载')
      return
    }
    
    // 构建完整消息内容，包含引用（如果有）
    let fullContent = content
    if (this.data.quotedContent) {
      fullContent = `引用: "${this.data.quotedContent}"\n\n${content}`
    }
    
    // 清空输入框并设置加载状态
    this.setData({
      inputValue: '',
      isLoading: true,
      quotedContent: '',
      quotedSource: '',
      loadingStartTime: Date.now() // 记录loading开始时间
    })
    
    // 显示全局loading效果
    wx.showLoading({
      title: '等待AI回答...',
      mask: true
    })
    
    // 添加用户消息到当前会话
    const userMessage = {
      role: 'user',
      content: fullContent,
      timestamp: Date.now()
    }
    
    // 确保有当前会话
    if (!app.globalData.currentSession) {
      app.createNewSession()
    }
    
    // 添加用户消息到当前会话
    app.globalData.currentSession.messages.push(userMessage)
    app.globalData.currentSession.updatedAt = Date.now()
    app.saveChatHistory()
    
    // 立即更新UI显示用户消息
    this.updateData()
    
    // 设置全局加载状态
    app.globalData.isLoading = true
    
    // 调用全局方法发送消息到API
    app.sendMessageToAPI(fullContent, (err, response) => {
      // 隐藏全局loading效果
      wx.hideLoading()
      
      // 更新全局和页面的加载状态
      app.globalData.isLoading = false
      this.setData({
        isLoading: false
      })
      
      // 更新页面数据以显示AI回复
      this.updateData()
      
      if (err) {
        wx.showToast({
          title: '发送失败: ' + err.message,
          icon: 'none',
          duration: 2000
        })
      }
    })
  },
  
  // 复制消息
  copyMessage(e) {
    const { content } = e.currentTarget.dataset
    wx.setClipboardData({
      data: content,
      success: () => {
        wx.showToast({
          title: '已复制到剪贴板',
          icon: 'success',
          duration: 1500
        })
      }
    })
  },
  
  // 重新发送消息
  resendMessage(e) {
    const { content } = e.currentTarget.dataset
    this.setData({
      inputValue: content
    }, () => {
      // 设置内容后自动聚焦输入框
      this.focusInput()
    })
  },
  
  // 聚焦输入框
  focusInput() {
    // 使用选择器获取输入框组件并设置焦点
    const query = wx.createSelectorQuery()
    query.select('.input-box').boundingClientRect()
    query.exec(res => {
      if (res[0]) {
        // 使用延时确保界面已经渲染完成
        setTimeout(() => {
          wx.createSelectorQuery().select('.input-box').fields({
            context: true,
          }, function(res) {
            res.node.focus()
          }).exec()
        }, 100)
      }
    })
  },
  
  // 引用消息
  quoteMessage(e) {
    const { content } = e.currentTarget.dataset
    const { message } = e.currentTarget.dataset
    const quotedText = content.length > 100 ? content.substring(0, 100) + '...' : content
    
    this.setData({
      quotedContent: quotedText,
      quotedSource: this.data.currentModelName || 'deepseek-v3'
    })
  },
  
  // 清除引用
  clearQuote() {
    this.setData({
      quotedContent: '',
      quotedSource: ''
    })
  },
  
  // 显示消息详情
  showMessageDetails(e) {
    const { message } = e.currentTarget.dataset
    
    console.log('消息详情对象:', message)
    
    let detailItems = []
    
    // 1. 模型信息
    if (message.model) {
      const modelObj = app.globalData.availableModels.find(m => m.id === message.model)
      detailItems.push({
        label: '模型',
        value: modelObj ? modelObj.name : message.model
      })
    } else {
      // 如果消息中没有模型信息，则显示当前会话的模型
      const currentSession = app.globalData.currentSession
      if (currentSession && currentSession.model) {
        const modelObj = app.globalData.availableModels.find(m => m.id === currentSession.model)
        detailItems.push({
          label: '模型',
          value: `${modelObj ? modelObj.name : currentSession.model} (估计)`
        })
      } else {
        detailItems.push({
          label: '模型',
          value: '未知'
        })
      }
    }
    
    // 2. Token信息
    if (message.tokens) {
      detailItems.push({
        label: '总Token数',
        value: message.tokens
      })
    }
    
    if (message.promptTokens) {
      detailItems.push({
        label: '提示Token',
        value: message.promptTokens
      })
    }
    
    if (message.completionTokens) {
      detailItems.push({
        label: '回复Token',
        value: message.completionTokens
      })
    }
    
    // 3. 响应时间
    if (message.responseTime) {
      // 确保显示为带1位小数的秒数
      let responseTimeDisplay;
      if (typeof message.responseTime === 'number') {
        responseTimeDisplay = message.responseTime.toFixed(1);
      } else {
        // 尝试转换为数字并格式化
        const responseTimeNum = parseFloat(message.responseTime);
        if (!isNaN(responseTimeNum)) {
          responseTimeDisplay = responseTimeNum.toFixed(1);
        } else {
          responseTimeDisplay = message.responseTime.toString();
        }
      }
      
      detailItems.push({
        label: '响应耗时',
        value: `${responseTimeDisplay}秒`
      })
    } else if (message.role === 'assistant') {
      detailItems.push({
        label: '响应耗时',
        value: '未记录'
      })
    }
    
    // 4. 时间戳
    if (message.timestamp) {
      const date = new Date(message.timestamp)
      detailItems.push({
        label: '时间',
        value: date.toLocaleString()
      })
    }
    
    this.displayDetails('消息详情', detailItems)
  },
  
  // 以更友好的方式显示详情
  displayDetails(title, items) {
    let content = ''
    let currentCategory = ''
    
    // 将详情项按类别分组
    items.forEach((item, index) => {
      // 确定当前项目的类别
      let category = ''
      if (item.label.includes('模型')) {
        category = 'model'
      } else if (item.label.includes('Token')) {
        category = 'token'
      } else if (item.label.includes('响应')) {
        category = 'response'
      } else if (item.label.includes('时间')) {
        category = 'time'
      }
      
      // 在不同类别之间添加分隔行
      if (currentCategory && currentCategory !== category) {
        content += '\n————————————————\n'
      }
      
      // 添加当前项目
      content += `${item.label}: ${item.value}\n`
      
      // 更新当前类别
      currentCategory = category
    })
    
    // 显示弹窗
    wx.showModal({
      title: title,
      content: content,
      showCancel: false
    })
  },
  
  // 打开模型选择器
  openModelSelector() {
    const globalData = app.globalData
    
    // 获取所有已启用的模型
    const enabledModels = globalData.availableModels.filter(
      model => globalData.enabledModelIds.includes(model.id)
    )
    
    console.log('已启用的模型:', globalData.enabledModelIds)
    console.log('可用的模型:', globalData.availableModels)
    console.log('筛选后的模型:', enabledModels)
    
    if (enabledModels.length === 0) {
      wx.showToast({
        title: '没有可用的模型',
        icon: 'none',
        duration: 2000
      })
      return
    }
    
    const items = enabledModels.map(model => ({
      name: model.name + (model.hasDeepThinking ? ' (支持深度思考)' : ''),
      id: model.id
    }))
    
    wx.showActionSheet({
      itemList: items.map(item => item.name),
      success: (res) => {
        const selectedModel = items[res.tapIndex]
        if (selectedModel) {
          // 获取选中的模型信息
          const modelInfo = globalData.availableModels.find(m => m.id === selectedModel.id)
          const currentModel = globalData.availableModels.find(m => m.id === globalData.currentSession?.model)
          
          // 如果当前是图片模型，且切换到非图片模型
          if (currentModel?.isImageModel && !modelInfo.isImageModel) {
            // 查找最近的非图片模型会话
            const lastNonImageSession = globalData.chatHistory.find(
              session => {
                const sessionModel = globalData.availableModels.find(m => m.id === session.model)
                return !sessionModel?.isImageModel
              }
            )
            
            if (lastNonImageSession) {
              // 恢复到最近的非图片模型会话
              globalData.currentSession = lastNonImageSession
              globalData.currentSession.model = selectedModel.id
            } else {
              // 如果没有找到非图片模型会话，创建新会话
              app.createNewSession(selectedModel.id)
            }
          }
          // 如果要切换到图片模型，创建新会话
          else if (modelInfo.isImageModel) {
            app.createNewSession(selectedModel.id)
          }
          // 其他情况（非图片模型之间切换），保持当前会话
          else if (globalData.currentSession) {
            globalData.currentSession.model = selectedModel.id
          } else {
            app.createNewSession(selectedModel.id)
          }
          
          app.saveChatHistory()
          this.updateData()
          
          wx.showToast({
            title: `已切换到 ${selectedModel.name}`,
            icon: 'none',
            duration: 1500
          })
        }
      }
    })
  },
  
  // 跳转到设置页面
  goToSettings() {
    wx.navigateTo({
      url: '/pages/settings/settings'
    })
  },
  
  // 跳转到历史记录页面
  goToHistory() {
    wx.navigateTo({
      url: '/pages/history/history'
    })
  },
  
  // 创建新对话
  createNewSession() {
    // 创建新会话
    app.createNewSession()
    
    // 更新页面数据
    this.updateData()
    
    // 显示提示
    wx.showToast({
      title: '已创建新对话',
      icon: 'success',
      duration: 1500
    })
  },
  
  // 预览图片
  previewImage(e) {
    const { url } = e.currentTarget.dataset;
    wx.previewImage({
      current: url,
      urls: [url]
    });
  },
  
  // 下载图片
  downloadImage(e) {
    const { url } = e.currentTarget.dataset;
    wx.showLoading({
      title: '正在保存...',
      mask: true
    });
    
    wx.downloadFile({
      url: url,
      success: (res) => {
        if (res.statusCode === 200) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              wx.showToast({
                title: '已保存到相册',
                icon: 'success',
                duration: 2000
              });
            },
            fail: (err) => {
              console.error('保存图片失败:', err);
              wx.showToast({
                title: '保存失败',
                icon: 'none',
                duration: 2000
              });
            }
          });
        } else {
          wx.showToast({
            title: '下载失败',
            icon: 'none',
            duration: 2000
          });
        }
      },
      fail: (err) => {
        console.error('下载图片失败:', err);
        wx.showToast({
          title: '下载失败',
          icon: 'none',
          duration: 2000
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },
  
  // 复制图片URL
  copyImageUrl(e) {
    const { url } = e.currentTarget.dataset;
    wx.setClipboardData({
      data: url,
      success: () => {
        wx.showToast({
          title: '已复制图片链接',
          icon: 'success',
          duration: 1500
        });
      }
    });
  }
}) 